Approximate Reasoning with Fuzzy Booleans

This paper introduces, in analogy to the concept of fuzzy numbers, the concept of fuzzy booleans, and examines approximate reasoning with the compositional rule of inference using fuzzy booleans. It is shown that each set of fuzzy rules is equivalent to a set of fuzzy rules with singleton crisp antecedents; in case of fuzzy booleans this set contains only two rules. It is shown that Zadeh's extension principle is equivalent to the compositional rule of inference using a complete set of fuzzy rules with singleton crisp antecedents. The results are applied to describe the use of approximate reasoning with fuzzy booleans to object-oriented design methods

Traceability for Model Driven, Software Product Line Engineering

Traceability is an important challenge for software organizations. This is true for traditional software development and even more so in new approaches that introduce more variety of artefacts such as Model Driven development or Software Product Lines. In this paper we look at some aspect of the interaction of Traceability, Model Driven development and Software Product Line

Imperfect Information in Software Design Processes

The process of designing high-quality software systems is one of the major issues in software engineering research. Over the years, this has resulted in numerous design methods, each with specific qualities and drawbacks. For example, the Rational Unified Process is a comprehensive design process, which is proposed to support the major phases in the software engineering life-cycle. Agile processes, like for instance Extreme Programming, aim at flexibility, since the design steps are not defined rigidly. Although the current software methods have largely proven their applicability and there exists a plethora of different design processes to be used, the current methods naturally suffer from the existence of imperfect information. Imperfection during software design is the occurrence of information, which is uncertain or incomplete to a certain degree. This can have many different causes, such as for instance incomplete information sources or an imprecise view of what the system should do. The existence of imperfection makes the design processes difficult to apply, since such information typically has one or more elements that are ambiguous in their interpretation. When a system is designed by using only one of the possible interpretations, there is a risk that the interpretation turns out to be wrong in due time. This can lead to redesigning the system, and consequently to very high costs. Unfortunately, current design methods neglect the existence of imperfect information. For example, modern software design processes explicitly require crisp and, preferably, complete requirement specifications, although it is generally acknowledged that this is difficult to accomplish. Similarly, imperfect information during design activities is also commonly neglected. However, imperfection is an inherent problem of almost every design process as well. Rather than trying to model the imperfection that inevitably exists, imperfection is generally neglected by making explicit and crisp assumptions, which may eventually result in wrong design decisions. The impact of neglecting imperfection in requirement specifications or design activities is higher in the early phases of software development. As the design process progresses, both the software engineers and the stakeholders may come to have new insights about what the system is supposed to do and which steps are to be taken. Because this information only becomes gradually available along with the design process, in the early phases it is not possible to transform imperfect information into a perfect one. In this thesis, we identify the problems in the two areas in which imperfect information can manifest itself, namely in contextual information (predominantly requirement specifications) and in software design activities. We analyze the types of imperfection, and the way in which the imperfection should be interpreted. Based on this analysis, we propose generic extensions to software design processes for modeling imperfect information. By this way, different interpretations of a design choice may be captured and considered according to their appropriateness without committing to one of them too early. By modeling alternative interpretations of a design choice, the design becomes more flexible. This is because the new insights which are gained during the software development process can be taken into account in the decision process more conveniently, without a need to redesign the system. In our proposed method we have combined the techniques used in various disciplines such as software architecture design, probability theory and fuzzy set theory, to ensure that we capture the relevant properties of both the software engineering process as well as the nature of the imperfect information. For a real-world application our approach can become very labor-intensive. In order to aid the software engineer, tooling support is considered essential. For this purpose the proposed methods have been implemented in a prototype. The tools relieve the user from the mathematical computation and optimization effort, and ensure that the user only has to focus on providing the relevant input. The effectiveness and ease of use of the tools are evaluated by means of a pilot study

Elimination of Constraints from Feature Trees

We present an algorithm which eliminates constraints from a feature model whose feature diagram is a tree and whose constraints are "requires" or "excludes" constraints. The algorithm constructs a feature tree which has the same semantics as the original feature model. The computational complexity of the algorithm is exponential in the number of constraints, but linear in the number of features. The algorithm allows to efficiently compute properties of product lines whose feature model consists of a feature tree and a small number of "requires" and "excludes" constraints. An executable specification of the algorithm is given in the functional programming language Miranda

The First International Workshop on Unanticipated Software Evolution

This workshop was dedicated to research towards better support for unanticipated software evolution (USE) in development tools, programming languages, component models and related runtime infrastructures. The report gives an overview of the submitted papers and summarizes the essence of discussions during plenary sessions and in working groups

Rankings from Fuzzy Pairwise Comparisons

We propose a new method for deriving rankings from fuzzy pairwise comparisons. It is based on the observation that quantification of the uncertainty of the pairwise comparisons should be used to obtain a better crisp ranking, instead of a fuzzified version of the ranking obtained from crisp pairwise comparisons. With our method, a crisp ranking is obtained by solving a linear programming problem, when the fuzzy pairwise comparisons are fuzzy triangular numbers. Our method simplifies the recent method by Mikhailov

La traçabilité dans les lignes de produits logiciels

Traceability is defined as the possibility to correlate the various artefacts (from requirement to source code) generated when developing software. In the context of software product line development, the problem is made even harder due to some characteristics specific to this software development approach. In this paper we discuss these problems specific to traceability for software product line development. We propose a taxonomy of traceability links. We also present a model to manage traceability of design decisions in the presence of uncertainty

A Market-Driven Approach Based on Markov Decision Theory for Optimal Use of Resources in Software Development

Changes in requirements may have a severe impact on development processes. For example, if requirements change during the course of a software development activity, it may be necessary to reschedule development activities so that the new requirements can be addressed in a timely manner. Unfortunately, current software development methods do not provide explicit means to adapt development processes with respect to changes in requirements. The paper proposes a method based on Markov decision theory, which determines the estimated optimal development schedule with respect to probabilistic product demands and resource constraints. This method is supported by a tool and applied to an industrial case

Fuzzy Weighted Average: Alternative Approach

We present an alternative definition of the fuzzy weighted average, in which Zadeh's extension principle is applied to the definition of the non-fuzzy weighted average where weights are required to be normalised. It is argued that the alternative approach should be preferred above the traditional approach. An algorithm for the computation of the fuzzy weighted average for the alternative approach is given for the case where attributes and weights are fuzzy triangular numbers. Several examples are worked out in detail